package utilities;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class HeaderContainer {
	public int rleType;
//	public int width;
//	public int height;
//	public int byteSize;
	public int redSquaresCount;
	public int redVSeriesCount;
		
	public int greenSquaresCount;
	public int greenVSeriesCount;
		
	public int blueSquaresCount;
	public int blueVSeriesCount;
	
	private byte[] header;
//	public int redSequenceSize;
	
//	public int greenSequenceSize;
	
//	public int blueSequenceSize;
	
//	public int hSeriesRedMarker;
	
//	public int hSeriesGreenMarker;
	
//	public int hSeriesBlueMarker;
	
	public int getThreeBytesValue(byte fst, byte sec, byte thr) {
		
		Byte fstByte = new Byte(fst);
		Byte secByte = new Byte(sec);
		Byte thrByte = new Byte(thr);
		
		
				
		int fstIntVal = fstByte.intValue() & 0xFF;
		int secIntVal = secByte.intValue() & 0xFF;
		int thrIntVal = thrByte.intValue() & 0xFF;
		
		
		return fstIntVal|(secIntVal<<8)|(thrIntVal<<16);
	}
	
	public int getTwoBytesValue(byte fst, byte sec) {
		Byte fstByte = new Byte(fst);
		Byte secByte = new Byte(sec);
				
		int fstIntVal = fstByte.intValue() & 0xFF;
		int secIntVal = secByte.intValue() & 0xFF;
		
		
		return fstIntVal|(secIntVal<<8);
	}
	
	public int getOneByteValue(byte fst) {
		Byte fstByte = new Byte(fst);
		int fstIntVal = fstByte.intValue() & 0xFF;
		return fstIntVal;
	}
	
	public void writeHeader(FileOutputStream fos) throws IOException {

		
//		byte [] binary = new byte [28];
//		
//		binary[0] = (byte)(width);
//		binary[1] = (byte)(width >> 8);
//		
//		binary[2] = (byte)(height);
//		binary[3] = (byte)(height >> 8);
//		
//		binary[4] = (byte)(redSquaresCount);
//		binary[5] = (byte)(redSquaresCount >> 8);
//			
//		binary[6] = (byte)(redVSeriesCount);
//		binary[7] = (byte)(redVSeriesCount >> 8);
//			
//		binary[8] = (byte)(greenSquaresCount);
//		binary[9] = (byte)(greenSquaresCount >> 8);
//			
//		binary[10] = (byte)(greenVSeriesCount);
//		binary[11] = (byte)(greenVSeriesCount >> 8);
//			
//		binary[12] = (byte)(blueSquaresCount);
//		binary[13] = (byte)(blueSquaresCount >> 8);
//			
//		binary[14] = (byte)(blueVSeriesCount);
//		binary[15] = (byte)(blueVSeriesCount >> 8);
//		
//		binary[16] = (byte)(redSequenceSize);
//		binary[17] = (byte)(redSequenceSize >> 8);
//		binary[18] = (byte)(redSequenceSize >> 16);
//		
//		binary[19] = (byte)(greenSequenceSize);
//		binary[20] = (byte)(greenSequenceSize >> 8);
//		binary[21] = (byte)(greenSequenceSize >> 16);
//		
//		binary[22] = (byte)(blueSequenceSize);
//		binary[23] = (byte)(blueSequenceSize >> 8);
//		binary[24] = (byte)(blueSequenceSize >> 16);
//		
//		binary[25] = (byte)(hSeriesRedMarker);
//		binary[26] = (byte)(hSeriesGreenMarker);
//		binary[27] = (byte)(hSeriesBlueMarker);
		if (this.rleType == rle2dUtilities.PCX_RLE){
			fos.write(header, 0, 26+3*256);
		} else {
			fos.write(header, 0, 29);
		}
	}
	
	public void readHeader(FileInputStream fis) throws IOException {
		header = new byte[26+3*256];
		byte rleByte;
		
		
		try {
			
			//get rle type
			
			rleByte = (byte)fis.read();
			this.rleType = getOneByteValue(rleByte);
			header[0] = rleByte;
			
			//get dimensions
			if (this.rleType == rle2dUtilities.PCX_RLE){
				fis.read(header,1,25+3*256);
			} else {
				fis.read(header,1,28);
			}
//			width = getTwoBytesValue(header[0], header[1]);
//			height = getTwoBytesValue(header[2], header[3]);
//			
//			if (width > 255 || height > 255)
//				this.byteSize = 2;
//			else
//				this.byteSize = 1;
				
			redSquaresCount = getTwoBytesValue(header[5],header[6]);
			redVSeriesCount = getTwoBytesValue(header[7],header[8]);
				
			greenSquaresCount = getTwoBytesValue(header[9], header[10]);
			greenVSeriesCount = getTwoBytesValue(header[11],header[12]);
				
			blueSquaresCount = getTwoBytesValue(header[13],header[14]);
			blueVSeriesCount = getTwoBytesValue(header[15],header[16]);
			
//			redSequenceSize = getThreeBytesValue(bytes[16], bytes[17], bytes[18]);
//			
//			greenSequenceSize = getThreeBytesValue(bytes[19], bytes[20], bytes[21]);
//			
//			blueSequenceSize = getThreeBytesValue(bytes[22], bytes[23], bytes[24]);
			
//			if(this.rleType == rle2dUtilities.PCX_RLE) {
//				byte[] mapBytes = new byte[256];
//				fis.read(mapBytes, 0, 256);
//				for(int i=0;i<256;i++) {
//					redPcxMap[i] = getOneByteValue(mapBytes[i]);
//				}
//				fis.read(mapBytes, 0, 256);
//				for(int i=0;i<256;i++) {
//					greenPcxMap[i] = getOneByteValue(mapBytes[i]);
//				}
//				fis.read(mapBytes, 0, 256);
//				for(int i=0;i<256;i++) {
//					bluePcxMap[i] = getOneByteValue(mapBytes[i]);
//				}
//				
//			}
//			else {
//				byte[] markersBytes = new byte[3];
//				fis.read(bytes,0,3);
//				this.hSeriesRedMarker = getOneByteValue(markersBytes[0]);
//				rle2dUtilities.H_SERIES_RED_MARKER = this.hSeriesRedMarker;
//				
//				this.hSeriesGreenMarker = getOneByteValue(markersBytes[1]);
//				rle2dUtilities.H_SERIES_GREEN_MARKER = this.hSeriesGreenMarker;
//				
//				this.hSeriesBlueMarker = getOneByteValue(markersBytes[2]);
//				rle2dUtilities.H_SERIES_BLUE_MARKER = this.hSeriesBlueMarker;
//			}
			
			
		} catch (Exception exc) {
			System.out.println("Nie udalo sie odczytac danych naglowka!");
			exc.printStackTrace();
		}
//		byte[] bytes = new byte[28];
//		
//		fis.read(bytes,0,28);
//		if(bytes != null) {
//			width = getTwoBytesValue(bytes[0], bytes[1]);
//			height = getTwoBytesValue(bytes[2], bytes[3]);
//			byteSize = 1;
//			if (width > 255 || height > 255)
//				byteSize = 2;
//			else
//				byteSize = 1;
//			
//			redSquaresCount = getTwoBytesValue(bytes[4],bytes[5]);
//			redVSeriesCount = getTwoBytesValue(bytes[6],bytes[7]);
//				
//			greenSquaresCount = getTwoBytesValue(bytes[8], bytes[9]);
//			greenVSeriesCount = getTwoBytesValue(bytes[10],bytes[11]);
//				
//			blueSquaresCount = getTwoBytesValue(bytes[12],bytes[13]);
//			blueVSeriesCount = getTwoBytesValue(bytes[14],bytes[15]);
//			
//			redSequenceSize = getThreeBytesValue(bytes[16], bytes[17], bytes[18]);
//			
//			greenSequenceSize = getThreeBytesValue(bytes[19], bytes[20], bytes[21]);
//			
//			blueSequenceSize = getThreeBytesValue(bytes[22], bytes[23], bytes[24]);
//			
//			hSeriesRedMarker = getOneByteValue(bytes[25]);
//			
//			hSeriesGreenMarker = getOneByteValue(bytes[26]);
//			
//			hSeriesBlueMarker = getOneByteValue(bytes[27]);
//		}
	}
}
